import axios, {
    type AxiosInstance,
    type InternalAxiosRequestConfig,  // 注意这里使用 InternalAxiosRequestConfig
    type AxiosResponse,
    type AxiosError,
    type AxiosRequestConfig,
} from 'axios';
import { type ApiResponse, type RequestOptions, type ApiError } from '../types/api';
import { messageApi } from './message';
import { useAuthStore } from '../store/authStore';

// 创建axios实例
const axiosInstance: AxiosInstance = axios.create({
    baseURL: import.meta.env.VITE_API_BASE_URL || '/api',
    timeout: 10000,
    headers: {
        'Content-Type': 'application/json',
    },
});

// 请求拦截器 - 修正类型
axiosInstance.interceptors.request.use(
    (config: InternalAxiosRequestConfig) => {  // 使用 InternalAxiosRequestConfig
        // 添加认证token
        const { token: storeToken } = useAuthStore.getState();
        const token = localStorage.getItem('auth_token');
        if (storeToken || token) {
            // 确保headers存在
            config.headers = config.headers || {};
            config.headers.Authorization = `Bearer ${storeToken || token}`;
        }
        return config;
    },
    (error: AxiosError<ApiResponse>) => {  // 这里也指定泛型类型
        return Promise.reject(wrapError(error));
    }
);

// 响应拦截器
axiosInstance.interceptors.response.use(
    (response: AxiosResponse<ApiResponse>) => {
        const { code, message: msg } = response.data;

        // 业务成功状态码（根据实际后端约定调整）
        if (code === 200) {
            // 保持返回完整的 AxiosResponse 对象，而不是仅返回 data
            return response;
        }

        // 业务错误统一处理（非200状态码）
        const error = new Error(msg) as ApiError;
        error.code = code;
        error.response = response;

        // // 全局错误提示（业务错误）
        // messageApi.error(msg || `操作失败 (${code})`);

        return Promise.reject(error);
    },
    (error: AxiosError<ApiResponse>) => {
        const wrappedError = wrapError(error);

        // // 全局错误提示（HTTP错误）
        // messageApi.error(wrappedError.message);

        return Promise.reject(wrappedError);
    }
);

/**
 * 包装错误信息
 */
function wrapError(error: AxiosError<ApiResponse>): ApiError {  // 明确指定AxiosError的响应数据类型为ApiResponse
    const wrappedError = new Error('网络请求失败') as ApiError;

    if (error.response) {
        const { data, status } = error.response;
        wrappedError.code = status;
        wrappedError.response = error.response;  // 此时response.data类型会匹配ApiResponse

        if (data && data.message) {
            wrappedError.message = data.message;
        } else {
            wrappedError.message = `请求失败 (${status})`;
        }
    } else if (error.request) {
        wrappedError.message = '请求超时，请检查网络';
    } else {
        wrappedError.message = error.message || '请求错误';
    }

    return wrappedError;
}

/**
 * 通用请求函数
 */
export async function request<T = any>(
    config: AxiosRequestConfig,
    options: RequestOptions<T> = {}
): Promise<T> {
    const {
        showError = true,
        showSuccess = false,
        successMessage,
        errorHandler,
        transformResponse,
    } = options;

    try {
        // 这里的 response 是完整的 AxiosResponse 对象
        const response = await axiosInstance.request<ApiResponse<T>>(config);
        const { data: apiData } = response.data;



        // 转换响应数据（返回业务数据部分）
        return transformResponse ? transformResponse(apiData) : apiData;
    } catch (error) {
        const apiError = error as ApiError;

        // // 自定义错误处理
        // if (errorHandler) {
        //     errorHandler(apiError);
        // } else if (showError) {
        //     // 默认错误提示
        //   messageApi.error(apiError.message);
        // }
        messageApi.error(apiError.message);

        throw apiError;
    }
}
/**
 * GET请求
 */
export function get<T = any>(
    url: string,
    params?: Record<string, any>,
    options?: RequestOptions<T>
) {
    return request<T>({ url, method: 'get', params }, options);
}

/**
 * POST请求
 */
export function post<T = any>(
    url: string,
    data?: any,
    options?: RequestOptions<T>
) {
    return request<T>({ url, method: 'post', data }, options);
}

/**
 * PUT请求
 */
export function put<T = any>(
    url: string,
    data?: any,
    options?: RequestOptions<T>
) {
    return request<T>({ url, method: 'put', data }, options);
}

/**
 * DELETE请求
 */
export function del<T = any>(
    url: string,
    params?: Record<string, any>,
    options?: RequestOptions<T>
) {
    return request<T>({ url, method: 'delete', params }, options);
}
export { axiosInstance };

export default {
    request,
    get,
    post,
    put,
    delete: del,
};

